/* Copyright (C) 2008  Romolo Camplani, Marco Fortunato, Marco Marelli, Guido Rota, Fabio A. Schreiber et al.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 */
/**
 * 
 */
package org.dei.perla.parser.expressions;

import org.dei.perla.sys.persistence.Null;

/**
 * Classe che definisce il tipo NULL
 * @author Stefano Vettor
 */
public class ConstantNull extends ConstantBuiltin<Null> {
		
	public String toString() {
		return "NULL";
	}
	
	/**
	 * Restituisce un oggetto Constant contenente il risultato dell'addizione
	 * tra la costante stessa e l'oggetto Costant passato come parametro
	 */
	public Constant<?> addition(Constant<?> parConst) throws OperationNotSupportedException, ConstantCastException {
		return new ConstantNull();
	}
	
	public static Class<? extends Constant<?>> additionResultType(Class<? extends Constant<?>> parConst) throws OperationNotSupportedException {
		return ConstantNull.class;
	}
	
	/**
	 * Restituisce un oggetto Constant contenente il risultato della sottrazione
	 * tra la costante stessa e l'oggetto Costant passato come parametro
	 */
	public Constant<?> subtraction(Constant<?> parConst) throws OperationNotSupportedException, ConstantCastException {
		return new ConstantNull();
	}
	
	public static Class<? extends Constant<?>> subtractionResultType(Class<? extends Constant<?>> parConst) throws OperationNotSupportedException {
		return ConstantNull.class;
	}
	
	/**
	 * Restituisce un oggetto Constant contenente il risultato della moltiplicazione
	 * tra la costante stessa e l'oggetto Costant passato come parametro
	 */
	public Constant<?> multiplication(Constant<?> parConst) throws OperationNotSupportedException, ConstantCastException {
		return new ConstantNull();
	}
	
	public static Class<? extends Constant<?>> multiplicationResultType(Class<? extends Constant<?>> parConst) throws OperationNotSupportedException {
		return ConstantNull.class;
	}
	
	/**
	 * Restituisce un oggetto Constant contenente il risultato della divisione
	 * tra la costante stessa e l'oggetto Costant passato come parametro
	 */
	public Constant<?> division(Constant<?> parConst) throws OperationNotSupportedException, ConstantCastException {
		return new ConstantNull();
	}
	
	public static Class<? extends Constant<?>> divisionResultType(Class<? extends Constant<?>> parConst) throws OperationNotSupportedException {
		return ConstantNull.class;
	}
	
	/**
	 * Restituisce un oggetto ConstantLogic contenente il risultato del confornto di uguaglianza
	 * tra la costante stessa e l'oggetto Costant passato come parametro
	 */
	public ConstantLogic isEqual(Constant<?> parConst) throws OperationNotSupportedException, ConstantCastException {
		return new ConstantLogic(LogicValue.UNKNOWN);
	}
	
	/**
	 * Restituisce un oggetto ConstantLogic contenente il risultato del confornto di disuguaglianza
	 * tra la costante stessa e l'oggetto Costant passato come parametro
	 */
	public ConstantLogic isUnequal(Constant<?> parConst) throws OperationNotSupportedException, ConstantCastException {
		return new ConstantLogic(LogicValue.UNKNOWN);
	}
	
	/**
	 * Restituisce un oggetto ConstantLogic contenente il risultato del confornto di maggiorita'
	 * tra la costante stessa e l'oggetto Costant passato come parametro
	 */
	public ConstantLogic isGreater(Constant<?> parConst) throws OperationNotSupportedException, ConstantCastException {
		return new ConstantLogic(LogicValue.UNKNOWN);
	}
	
	/**
	 * Restituisce un oggetto ConstantLogic contenente il risultato del confornto di stretta maggiorita' (uguaglianza non inclusa)
	 * tra la costante stessa e l'oggetto Costant passato come parametro
	 */
	public ConstantLogic isStrictlyGreater(Constant<?> parConst) throws OperationNotSupportedException, ConstantCastException {
		return new ConstantLogic(LogicValue.UNKNOWN);
	}
	
	/**
	 * Restituisce un oggetto ConstantLogic contenente il risultato del confornto di minorit�
	 * tra la costante stessa e l'oggetto Costant passato come parametro
	 */
	public ConstantLogic isMinor(Constant<?> parConst) throws OperationNotSupportedException, ConstantCastException {
		return new ConstantLogic(LogicValue.UNKNOWN);
	}
	
	/**
	 * Restituisce un oggetto ConstantLogic contenente il risultato del confornto di stretta minorita' (uguaglianza non inclusa)
	 * tra la costante stessa e l'oggetto Costant passato come parametro
	 */
	public ConstantLogic isStrictlyMinor(Constant<?> parConst) throws OperationNotSupportedException, ConstantCastException {
		return new ConstantLogic(LogicValue.UNKNOWN);
	}
	
	/**
	 * Restituisce un oggetto ConstantLogic contenente il risultato del confornto invertito di maggiorita'
	 * tra la costante stessa e l'oggetto Costant passato come parametro
	 */
	public ConstantLogic isGreaterInverse(Constant<?> parConst) throws OperationNotSupportedException, ConstantCastException {
		return new ConstantLogic(LogicValue.UNKNOWN);
	}
	
	/**
	 * Restituisce un oggetto ConstantLogic contenente il risultato del confornto invertito di stretta maggiorita' (uguaglianza non inclusa)
	 * tra la costante stessa e l'oggetto Costant passato come parametro
	 */
	public ConstantLogic isStrictlyGreaterInverse(Constant<?> parConst) throws OperationNotSupportedException, ConstantCastException {
		return new ConstantLogic(LogicValue.UNKNOWN);
	}
	
	/**
	 * Restituisce un oggetto ConstantLogic contenente il risultato del confornto invertito di minorit�
	 * tra la costante stessa e l'oggetto Costant passato come parametro
	 */
	public ConstantLogic isMinorInverse(Constant<?> parConst) throws OperationNotSupportedException, ConstantCastException {
		return new ConstantLogic(LogicValue.UNKNOWN);
	}
	
	/**
	 * Restituisce un oggetto ConstantLogic contenente il risultato del confornto invertito di stretta minorita' (uguaglianza non inclusa)
	 * tra la costante stessa e l'oggetto Costant passato come parametro
	 */
	public ConstantLogic isStrictlyMinorInverse(Constant<?> parConst) throws OperationNotSupportedException, ConstantCastException {
		return new ConstantLogic(LogicValue.UNKNOWN);
	}
	
	public ConstantLogic isBetween(Constant<?> parConstBegin, Constant<?> parConstEnd) throws OperationNotSupportedException, ConstantCastException {
		return new ConstantLogic(LogicValue.UNKNOWN);
	}
	
	/**
	 * Restituisce un oggetto ConstantLogic (o ConstantNull in alcuni casi) rispecchiante l'operazione AND
	 * tra la classe e l'oggetto parConst passaro come parametro.
	 */
	public ConstantLogic and(Constant<?> parConst) throws OperationNotSupportedException, ConstantCastException {
		return new ConstantLogic(LogicValue.UNKNOWN);
	}
	
	public static Class<? extends Constant<?>> andResultType(Class<? extends Constant<?>> parConst) throws OperationNotSupportedException {
		return ConstantLogic.class;
	}
	
	/**
	 * Restituisce un oggetto ConstantLogic (o ConstantNull in alcuni casi) rispecchiante l'operazione OR
	 * tra la classe e l'oggetto parConst passaro come parametro.
	 */
	public ConstantLogic or(Constant<?> parConst) throws OperationNotSupportedException, ConstantCastException {
		return new ConstantLogic(LogicValue.UNKNOWN);
	}
	
	public static Class<? extends Constant<?>> orResultType(Class<? extends Constant<?>> parConst) throws OperationNotSupportedException {
		return ConstantLogic.class;
	}
	
	/**
	 * Restituisce un oggetto ConstantLogic (o ConstantNull in alcuni casi) rispecchiante l'operazione XOR
	 * tra la classe e l'oggetto parConst passaro come parametro.
	 */
	public ConstantLogic xor(Constant<?> parConst) throws OperationNotSupportedException, ConstantCastException {
		return new ConstantLogic(LogicValue.UNKNOWN);
	}
	
	public static Class<? extends Constant<?>> xorResultType(Class<? extends Constant<?>> parConst) throws OperationNotSupportedException {
		return ConstantLogic.class;
	}
	
	/**
	 * Restituisce un oggetto ConstantLogic (o ConstantNull in alcuni casi) rispecchiante l'operazione NOT
	 * sulla classe stessa.
	 */
	public ConstantLogic not() throws OperationNotSupportedException {
		return new ConstantLogic(LogicValue.UNKNOWN);
	}
	
	public static Class<? extends Constant<?>> notResultType() throws OperationNotSupportedException {
		return ConstantLogic.class;
	}
	
	public Constant<?> bitwiseAND(Constant<?> parConst) throws OperationNotSupportedException, ConstantCastException {
		return new ConstantNull();
	}
	
	public static Class<? extends Constant<?>> bitwiseANDResultType(Class<? extends Constant<?>> parConst) throws OperationNotSupportedException {
		return ConstantNull.class;
	}
	
	public Constant<?> bitwiseOR(Constant<?> parConst) throws OperationNotSupportedException, ConstantCastException {
		return new ConstantNull();
	}
	
	public static Class<? extends Constant<?>> bitwiseORResultType(Class<? extends Constant<?>> parConst) throws OperationNotSupportedException {
		return ConstantNull.class;
	}
	
	public Constant<?> bitwiseXOR(Constant<?> parConst) throws OperationNotSupportedException, ConstantCastException {
		return new ConstantNull();
	}
	
	public static Class<? extends Constant<?>> bitwiseXORResultType(Class<? extends Constant<?>> parConst) throws OperationNotSupportedException {
		return ConstantNull.class;
	}
	
	public Constant<?> bitwiseNOT() throws OperationNotSupportedException, ConstantCastException {
		return new ConstantNull();
	}
	
	public static Class<? extends Constant<?>> bitwiseNOTResultType() throws OperationNotSupportedException {
		return ConstantNull.class;
	}
	
	public Constant<?> bitwiseRightShift(Constant<?> parConst) throws OperationNotSupportedException, ConstantCastException {
		return new ConstantNull();
	}
	
	public static Class<? extends Constant<?>> bitwiseRightShiftResultType(Class<? extends Constant<?>> parConst) throws OperationNotSupportedException {
		return ConstantNull.class;
	}
	
	public Constant<?> bitwiseLeftShift(Constant<?> parConst) throws OperationNotSupportedException, ConstantCastException {
		return new ConstantNull();
	}
	
	public static Class<? extends Constant<?>> bitwiseLeftShiftResultType(Class<? extends Constant<?>> parConst) throws OperationNotSupportedException {
		return ConstantNull.class;
	}
	
	public ConstantLogic isLike(Constant<?> parConst) throws OperationNotSupportedException, ConstantCastException {
		return new ConstantLogic(LogicValue.UNKNOWN);
	}
	
	public static Class<? extends Constant<?>> isLikeResultType(Class<? extends Constant<?>> parConst) throws OperationNotSupportedException {
		return (Class<? extends Constant<?>>) ConstantLogic.class;
	}
	
	public ConstantLogic is(Constant<?> parConst) throws OperationNotSupportedException, ConstantCastException {
		return new ConstantLogic(LogicValue.UNKNOWN);
	}
	
	public static Class<? extends Constant<?>> isResultType(Class<? extends Constant<?>> parConst) throws OperationNotSupportedException {
		return ConstantLogic.class;
	}
	
	public Constant<?> sign() throws OperationNotSupportedException, ConstantCastException {
		return new ConstantNull();
	}
	
	public static Class<? extends Constant<?>> signResultType() throws OperationNotSupportedException {
		return ConstantNull.class;
	}
	
	public ConstantLogic exist(Constant<?> parConst) throws OperationNotSupportedException, ConstantCastException {
		return new ConstantLogic(LogicValue.UNKNOWN);
	}
	
	public static Class<? extends Constant<?>> existResultType(Class<? extends Constant<?>> parConst) throws OperationNotSupportedException {
		return ConstantLogic.class;
	}
	
	/**
	 * Dato un tipo Constant il metodo ritorna true se ConstantNull supporta le operazioni
	 * di uguaglianza e disuguaglianza con la classe Constant<?> passata come parametro. In caso contrario ritorna false.
	 * @param parConst
	 * @return
	 */
	public static boolean isEquallyComparable(Class<? extends Constant<?>> parConst) {
		return true;
	}
	
	/**
	 * Dato un tipo Constant il metodo ritorna true se ConstantNull supporta le operazioni
	 * di uguaglianza, disuguaglianza, maggiorit� e minorit� con la classe Constant<?> passata come parametro. In caso contrario ritorna false.
	 * @param parConst
	 * @return
	 */
	public static boolean isFullyComparable(Class<? extends Constant<?>> parConst) {
		return true;
	}
	
	@Override
	public boolean isNull() {
		return true;
	}
	
	@Override
	public Null getSqlValue() {
		return new Null();
	}

	@Override
	public boolean isUserDefined() {
		return false;
	}

}
